﻿using System;
using System.Collections.Generic;
using System.Text;
using Csla;
using System.Data.Odbc;
using MinaspetroLibrary.Configuracoes;
using System.Data;
using Csla.Data;

namespace MinaspetroLibrary.AssociadoPack
{
    [Serializable()]
    public class Associado : BusinessBase<Associado>
    {
        #region Control Properties
        [Csla.NotUndoable()]
        private bool _isEmpty = false;

        public bool IsEmpty
        {
            get { return _isEmpty; }
        }
        #endregion

        #region Business Properties and Methods

        private Guid _id = Guid.NewGuid();

        private string _numControle = string.Empty;

        private string _razaoSocial = string.Empty;

        private string _nomeFantasia = string.Empty;

        private int _idTipoCliente = 0; //por default é interessado

        private string _idEnderecoRevendedor = string.Empty;

        private string _idContatoRevendedor = string.Empty;

        private string _idEnderecoCorresp = string.Empty;

        private string _cnpj = string.Empty;

        private string _inscEstadual = string.Empty;

        private string _inscMunicipal = string.Empty;

        private string _cnpjLojaConv = string.Empty;

        private string _bandeiraLojaConv = string.Empty;

        private string _servOleo = string.Empty;

        private string _tipoPosto = string.Empty;

        private string _bandeiraPosto = string.Empty;

        private DateTime _dataContratoBandeira = DateTime.Now;
        
        private string _nomeContador = string.Empty;
        
        private string _escritorioContador = string.Empty;

        private string _idEnderecoContador = string.Empty;

        private string _idContatoContador = string.Empty;

        private DateTime _dataContador = DateTime.Now;
        
        private string _informanteContador = string.Empty;

        private string _observacoes = string.Empty;

        private DateTime _dataSolicitacao = DateTime.Now;

        private char _publicar = 'N'; //N por default


        [System.ComponentModel.DataObjectField(true, true)]
        public Guid Id
        {
            get
            {
                CanReadProperty("Id", true);
                return _id;
            }
        }

        public string RazaoSocial
        {
            get
            {
                CanReadProperty("RazaoSocial", true);
                return _razaoSocial;
            }
            set
            {
                CanWriteProperty("RazaoSocial", true);
                if (value == null) value = string.Empty;
                if (!_razaoSocial.Equals(value))
                {
                    _razaoSocial = value;
                    PropertyHasChanged("RazaoSocial");
                }
            }
        }

        public string NumControle
        {
            get
            {
                CanReadProperty("NumControle", true);
                return _numControle;
            }
            set
            {
                CanWriteProperty("NumControle", true);
                if (!_numControle.Equals(value))
                {
                    _numControle = value;
                    PropertyHasChanged("NumControle");
                }
            }
        }

        public string NomeFantasia
        {
            get
            {
                CanReadProperty("NomeFantasia", true);
                return _nomeFantasia;
            }
            set
            {
                CanWriteProperty("NomeFantasia", true);
                if (value == null) value = string.Empty;
                if (!_nomeFantasia.Equals(value))
                {
                    _nomeFantasia = value;
                    PropertyHasChanged("NomeFantasia");
                }
            }
        }

        public string IdEnderecoRevendedor
        {
            get
            {
                CanReadProperty("IdEnderecoRevendedor", true);
                return _idEnderecoRevendedor;
            }
            set
            {
                CanWriteProperty("IdEnderecoRevendedor", true);
                if (value == null) value = string.Empty;
                if (!_idEnderecoRevendedor.Equals(value))
                {
                    _idEnderecoRevendedor = value;
                    PropertyHasChanged("IdEnderecoRevendedor");
                }
            }
        }

        public int IdTipoCliente
        {
            get
            {
                CanReadProperty("IdTipoCliente", true);
                return _idTipoCliente;
            }
            set
            {
                CanWriteProperty("IdTipoCliente", true);
                if (_idTipoCliente == value)
                {
                    _idTipoCliente = value;
                    PropertyHasChanged("IdTipoCliente");
                }
            }
        }

        public string IdContatoRevendedor
        {
            get
            {
                CanReadProperty("IdContatoRevendedor", true);
                return _idContatoRevendedor;
            }
            set
            {
                CanWriteProperty("IdContatoRevendedor", true);
                if (value == null) value = string.Empty;
                if (!_idContatoRevendedor.Equals(value))
                {
                    _idContatoRevendedor = value;
                    PropertyHasChanged("IdContatoRevendedor");
                }
            }
        }

        public string IdEnderecoCorresp
        {
            get
            {
                CanReadProperty("IdEnderecoCorresp", true);
                return _idEnderecoCorresp;
            }
            set
            {
                CanWriteProperty("IdEnderecoCorresp", true);
                if (value == null) value = string.Empty;
                if (!_idEnderecoCorresp.Equals(value))
                {
                    _idEnderecoCorresp = value;
                    PropertyHasChanged("IdEnderecoCorresp");
                }
            }
        }

        public string Cnpj
        {
            get
            {
                CanReadProperty("Cnpj", true);
                return _cnpj;
            }
            set
            {
                CanWriteProperty("Cnpj", true);
                if (value == null) value = string.Empty;
                if (!_cnpj.Equals(value))
                {
                    _cnpj = value;
                    PropertyHasChanged("Cnpj");
                }
            }
        }

        public string InscEstadual
        {
            get
            {
                CanReadProperty("InscEstadual", true);
                return _inscEstadual;
            }
            set
            {
                CanWriteProperty("InscEstadual", true);
                if (value == null) value = string.Empty;
                if (!_inscEstadual.Equals(value))
                {
                    _inscEstadual = value;
                    PropertyHasChanged("InscEstadual");
                }
            }
        }

        public string InscMunicipal
        {
            get
            {
                CanReadProperty("InscMunicipal", true);
                return _inscMunicipal;
            }
            set
            {
                CanWriteProperty("InscMunicipal", true);
                if (value == null) value = string.Empty;
                if (!_inscMunicipal.Equals(value))
                {
                    _inscMunicipal = value;
                    PropertyHasChanged("InscMunicipal");
                }
            }
        }

        public string CnpjLojaConv
        {
            get
            {
                CanReadProperty("CnpjLojaConv", true);
                return _cnpjLojaConv;
            }
            set
            {
                CanWriteProperty("CnpjLojaConv", true);
                if (value == null) value = string.Empty;
                if (!_cnpjLojaConv.Equals(value))
                {
                    _cnpjLojaConv = value;
                    PropertyHasChanged("CnpjLojaConv");
                }
            }
        }

        public string BandeiraLojaConv
        {
            get
            {
                CanReadProperty("BandeiraLojaConv", true);
                return _bandeiraLojaConv;
            }
            set
            {
                CanWriteProperty("CnpjLojaConv", true);
                if (value == null) value = string.Empty;
                if (!_bandeiraLojaConv.Equals(value))
                {
                    _bandeiraLojaConv = value;
                    PropertyHasChanged("BandeiraLojaConv");
                }
            }
        }

        public string ServOleo
        {
            get
            {
                CanReadProperty("ServOleo", true);
                return _servOleo;
            }
            set
            {
                CanWriteProperty("ServOleo", true);
                if (value == null) value = string.Empty;
                if (!_servOleo.Equals(value))
                {
                    _servOleo = value;
                    PropertyHasChanged("ServOleo");
                }
            }
        }

        public string TipoPosto
        {
            get
            {
                CanReadProperty("TipoPosto", true);
                return _tipoPosto;
            }
            set
            {
                CanWriteProperty("TipoPosto", true);
                if (value == null) value = string.Empty;
                if (!_tipoPosto.Equals(value))
                {
                    _tipoPosto = value;
                    PropertyHasChanged("TipoPosto");
                }
            }
        }

        public string BandeiraPosto
        {
            get
            {
                CanReadProperty("BandeiraPosto", true);
                return _bandeiraPosto;
            }
            set
            {
                CanWriteProperty("BandeiraPosto", true);
                if (value == null) value = string.Empty;
                if (!_bandeiraPosto.Equals(value))
                {
                    _bandeiraPosto = value;
                    PropertyHasChanged("BandeiraPosto");
                }
            }
        }

        public DateTime DataContratoBandeira
        {
            
            get
            {
                CanReadProperty("DataContratoBandeira", true);
                return _dataContratoBandeira;
            }
            set
            {
                CanWriteProperty("DataContratoBandeira", true);
                if (!_dataContratoBandeira.Equals(value))
                {
                    _dataContratoBandeira = value;
                    PropertyHasChanged("DataContratoBandeira");
                }
            }            
        }

        public string DataContratoBandeiraShortString
        {
            get
            {
                CanReadProperty("DataContratoBandeira", true);
                return _dataContratoBandeira.ToString("dd/MM/yyyy");
            }
        }

        public string DataContratoBandeiraFullString
        {
            get
            {
                CanReadProperty("DataContratoBandeira", true);
                return _dataContratoBandeira.ToString("dd/MM/yyyy HH:mm");
            }
        }

        public string NomeContador
        {
            get
            {
                CanReadProperty("NomeContador", true);
                return _nomeContador;
            }
            set
            {
                CanWriteProperty("NomeContador", true);
                if (value == null) value = string.Empty;
                if (!_nomeContador.Equals(value))
                {
                    _nomeContador = value;
                    PropertyHasChanged("NomeContador");
                }
            }
        }

        public string EscritorioContador
        {
            get
            {
                CanReadProperty("EscritorioContador", true);
                return _escritorioContador;
            }
            set
            {
                CanWriteProperty("EscritorioContador", true);
                if (value == null) value = string.Empty;
                if (!_escritorioContador.Equals(value))
                {
                    _escritorioContador = value;
                    PropertyHasChanged("EscritorioContador");
                }
            }
        }

        public string IdEnderecoContador
        {
            get
            {
                CanReadProperty("IdEnderecoContador", true);
                return _idEnderecoContador;
            }
            set
            {
                CanWriteProperty("IdEnderecoContador", true);
                if (value == null) value = string.Empty;
                if (!_idEnderecoContador.Equals(value))
                {
                    _idEnderecoContador = value;
                    PropertyHasChanged("IdEnderecoContador");
                }
            }
        }

        public string IdContatoContador
        {
            get
            {
                CanReadProperty("IdContatoContador", true);
                return _idContatoContador;
            }
            set
            {
                CanWriteProperty("IdContatoContador", true);
                if (value == null) value = string.Empty;
                if (!_idContatoContador.Equals(value))
                {
                    _idContatoContador = value;
                    PropertyHasChanged("IdContatoContador");
                }
            }
        }

        public DateTime DataContador
        {
            get
            {
                CanReadProperty("DataContador", true);
                return _dataContador;
            }
            set
            {
                CanWriteProperty("DataContador", true);
                if (!_dataContador.Equals(value))
                {
                    _dataContador = value;
                    PropertyHasChanged("DataContador");
                }
            }            
            
        }

        public string DataContadorShortString
        {
            get
            {
                CanReadProperty("DataContador", true);
                return _dataContador.ToString("dd/MM/yyyy");
            }
        }

        public string DataContadorFullString
        {
            get
            {
                CanReadProperty("DataContador", true);
                return _dataContador.ToString("dd/MM/yyyy HH:mm");
            }
        }

        public string InformanteContador
        {
            get
            {
                CanReadProperty("InformanteContador", true);
                return _informanteContador;
            }
            set
            {
                CanWriteProperty("InformanteContador", true);
                if (value == null) value = string.Empty;
                if (!_informanteContador.Equals(value))
                {
                    _informanteContador = value;
                    PropertyHasChanged("InformanteContador");
                }
            }
        }

        public string Observacoes
        {
            get
            {
                CanReadProperty("Observacoes", true);
                return _observacoes;
            }
            set
            {
                CanWriteProperty("Observacoes", true);
                if (value == null) value = string.Empty;
                if (!_observacoes.Equals(value))
                {
                    _observacoes = value;
                    PropertyHasChanged("Observacoes");
                }
            }
        }

        public DateTime DataSolicitacao
        {
            get
            {
                CanReadProperty("DataSolicitacao", true);
                return _dataSolicitacao;
            }
            set
            {
                CanWriteProperty("DataSolicitacao", true);
                if (!_dataSolicitacao.Equals(value))
                {
                    _dataSolicitacao = value;
                    PropertyHasChanged("DataSolicitacao");
                }
            }
        }

        public string DataSolicitacaoShortString
        {
            get
            {
                CanReadProperty("DataSolicitacao", true);
                return _dataSolicitacao.ToString("dd/MM/yyyy");
            }
        }

        public string DataSolicitacaoFullString
        {
            get
            {
                CanReadProperty("DataSolicitacao", true);
                return _dataSolicitacao.ToString("dd/MM/yyyy HH:mm");
            }
        }

        public char Publicar
        {
            get
            {
                CanReadProperty("Publicar", true);
                return _publicar;
            }
            set
            {
                CanWriteProperty("Publicar", true);
                if (!_publicar.Equals(value))
                {
                    _publicar = value;
                    PropertyHasChanged("Publicar");
                }
            }
        }

        protected override object GetIdValue()
        {
            return _id.ToString();
        }

        #endregion //Business Properties and Methods

        #region Validation Rules
        private void AddCustomRules()
        {
            //add custom/non-generated rules here...
        }

        private void AddCommonRules()
        {
        }

        protected override void AddBusinessRules()
        {
            AddCommonRules();
            AddCustomRules();
        }
        #endregion //Validation Rules

        #region Authorization Rules
        protected override void AddAuthorizationRules()
        {
            //TODO: Define authorization rules in Associado
        }


        public static bool CanGetObject()
        {
            //TODO: Define CanGetObject permission in Associado
            return true;
            //if (Csla.ApplicationContext.User.IsInRole("AssociadoViewGroup"))
            //	return true;
            //return false;
        }

        public static bool CanAddObject()
        {
            //TODO: Define CanAddObject permission in Associado
            return true;
            //if (Csla.ApplicationContext.User.IsInRole("AssociadoAddGroup"))
            //	return true;
            //return false;
        }

        public static bool CanEditObject()
        {
            //TODO: Define CanEditObject permission in Associado
            return true;
            //if (Csla.ApplicationContext.User.IsInRole("AssociadoEditGroup"))
            //	return true;
            //return false;
        }

        public static bool CanDeleteObject()
        {
            //TODO: Define CanDeleteObject permission in Associado
            return true;
            //if (Csla.ApplicationContext.User.IsInRole("AssociadoDeleteGroup"))
            //	return true;
            //return false;
        }
        #endregion //Authorization Rules

        #region Factory Methods
        private Associado()
        { /* require use of factory method */ }

        public static Associado NewAssociado()
        {
            if (!CanAddObject())
                throw new System.Security.SecurityException("Usuário não autorizado a adicionar Associado");
            return DataPortal.Create<Associado>();
        }


        private static Associado objNovo = null;

        public static Associado NovoAssociado()
        {
            if (!CanAddObject())
                throw new System.Security.SecurityException("Usuário não autorizado a adicionar Associado");

            if (objNovo == null)
                objNovo = new Associado();

            return objNovo;
        }

        public static Associado GetAssociado(Guid id)
        {
            if (!CanGetObject())
                throw new System.Security.SecurityException("Usuário não autorizado a visualizar Associado");
            return DataPortal.Fetch<Associado>(new Criteria(id));
        }

        public static Associado GetAssociado(String Cnpj)
        {
            if (!CanGetObject())
                throw new System.Security.SecurityException("Usuário não autorizado a visualizar Associado");
            return DataPortal.Fetch<Associado>(new Criteria(Cnpj));
        }

        public override Associado Save()
        {
            if (IsDeleted && !CanDeleteObject())
                throw new System.Security.SecurityException("Usuário não autorizado a remover Associado");
            else if (IsNew && !CanAddObject())
                throw new System.Security.SecurityException("Usuário não autorizado a adicionar Associado");
            else if (!CanEditObject())
                throw new System.Security.SecurityException("Usuário não autorizado a atualizar Associado");

            return base.Save();
        }

        public static void DeleteAssociado(Guid id)
        {
            if (!CanDeleteObject())
                throw new System.Security.SecurityException("Usuário não autorizado a remover Associado");
            DataPortal.Delete(new Criteria(id));
        }

        #endregion

        #region Data Access

        #region Criteria

        [Serializable()]
        private class Criteria
        {
            public Guid Id = Guid.Empty;
            public String Cnpj = String.Empty;

            public Criteria(Guid Id)
            {
                this.Id = Id;

            }

            public Criteria(String Cnpj)
            {
                this.Cnpj = Cnpj;

            }
        }


        #endregion //Criteria

        #region Data Access - Create
        [RunLocal]
        protected override void DataPortal_Create()
        {
            _isEmpty = false;
            ValidationRules.CheckRules();
        }

        #endregion //Data Access - Create

        #region Data Access - Fetch
        private void DataPortal_Fetch(Criteria criteria)
        {
            using (OdbcConnection cn = new OdbcConnection(ConfigDatabase.MinaspetroConnection))
            {
                cn.Open();
                ExecuteFetch(cn, criteria);
            }
        }

        private void ExecuteFetch(OdbcConnection cn, Criteria criteria)
        {
            using (OdbcCommand cm = cn.CreateCommand())
            {
                cm.CommandType = CommandType.Text;
                cm.CommandText = GetFetchScript(criteria);

                using (SafeDataReader dr = new SafeDataReader(cm.ExecuteReader()))
                {
                    FetchObject(dr);
                    ValidationRules.CheckRules();
                    FetchChildren(dr);
                }
            }
        }

        private string GetFetchScript(Criteria criteria)
        {
            String strQuery = "SELECT "
                + "Id, "
                + "NumControle, "
                + "RazaoSocial, "
                + "NomeFantasia, "
                + "IdTipoCliente, "
                + "IdEnderecoRevendedor, "
                + "IdContatoRevendedor, "
                + "IdEnderecoCorresp, "
                + "Cnpj, "
                + "InscEstadual, "
                + "InscMunicipal, "
                + "CnpjLojaConv, "
                + "BandeiraLojaConv, "
                + "ServOleo, "
                + "TipoPosto, "
                + "BandeiraPosto, "
                + "DataContratoBandeira, "
                + "NomeContador, "
                + "EscritorioContador, "
                + "IdEnderecoContador, "
                + "IdContatoContador, "
                + "DataContador, "
                + "InformanteContador, "
                + "Observacoes, "
                + "DataSolicitacao, "
                + "Publicar "
                + "FROM associadotb ";

            if (criteria.Id == Guid.Empty && !criteria.Cnpj.Equals(String.Empty))
                strQuery += " WHERE Cnpj=\"" + criteria.Cnpj.Trim().Replace("\"", "\\\"") + "\" AND Publicar = 's';";
                 else
                    strQuery+= " WHERE Id=\"" + criteria.Id.ToString() + "\";";


             return strQuery;
        }

        private void FetchObject(SafeDataReader dr)
        {
            _isEmpty = !dr.Read();
            if (_isEmpty) return;
            _id = new Guid(dr["Id"].ToString());
            _numControle = dr.GetString("NumControle");
            _razaoSocial = dr.GetString("RazaoSocial");
            _nomeFantasia = dr.GetString("NomeFantasia");
            _idTipoCliente = dr.GetInt32("IdTipoCliente");
            _idEnderecoRevendedor = dr.GetString("IdEnderecoRevendedor");
            _idContatoRevendedor = dr.GetString("IdContatoRevendedor");
            _idEnderecoCorresp = dr.GetString("IdEnderecoCorresp");
            _cnpj = dr.GetString("Cnpj");
            _inscEstadual = dr.GetString("InscEstadual");
            _inscMunicipal = dr.GetString("InscMunicipal");
            _cnpjLojaConv = dr.GetString("CnpjLojaConv");
            _bandeiraLojaConv = dr.GetString("BandeiraLojaConv");
            _servOleo = dr.GetString("ServOleo");
            _tipoPosto = dr.GetString("TipoPosto");
            _bandeiraPosto = dr.GetString("BandeiraPosto");
            _dataContratoBandeira = dr.GetDateTime("DataContratoBandeira");
            _nomeContador = dr.GetString("NomeContador");
            _escritorioContador = dr.GetString("EscritorioContador");
            _idEnderecoContador = dr.GetString("IdEnderecoContador");
            _idContatoContador = dr.GetString("IdContatoContador");
            _dataContador = dr.GetDateTime("DataContador");
            _informanteContador = dr.GetString("InformanteContador");
            _observacoes = dr.GetString("Observacoes");
            _dataSolicitacao = dr.GetDateTime("DataSolicitacao");
            _publicar = dr.GetChar("Publicar");
        }

        private void FetchChildren(SafeDataReader dr)
        {
        }
        #endregion //Data Access - Fetch

        #region Data Access - Insert
        protected override void DataPortal_Insert()
        {
            using (OdbcConnection cn = new OdbcConnection(ConfigDatabase.MinaspetroConnection))
            {
                cn.Open();

                ExecuteInsert(cn);

                //update child object(s)
                UpdateChildren(cn);
            }//using
            MinaspetroLibrary.UsuarioPack.Usuario.UsuarioInSession.AtualizarHitorico("Insert - associadotb - Id: " + _id.ToString());
        }

        private void ExecuteInsert(OdbcConnection cn)
        {
            using (OdbcCommand cm = cn.CreateCommand())
            {
                cm.CommandType = CommandType.Text;
                cm.CommandText = GetInsertScript();
                cm.ExecuteNonQuery();
            }//using
        }

        private string GetInsertScript()
        {
            return "INSERT INTO associadotb "
                + "( Id, NumControle, RazaoSocial, NomeFantasia, IdTipoCliente, IdEnderecoRevendedor, IdContatoRevendedor, IdEnderecoCorresp, "
                   + "Cnpj, InscEstadual, InscMunicipal, CnpjLojaConv, BandeiraLojaConv, ServOleo, TipoPosto, BandeiraPosto, DataContratoBandeira, "
                   + "NomeContador, EscritorioContador, IdEnderecoContador, IdContatoContador, DataContador, InformanteContador, "
                   + "Observacoes, DataSolicitacao, Publicar) "
                + " VALUES (\""
                + _id.ToString().Trim().Replace("\"", "\\\"") + "\", \""
                + _numControle.ToString().Trim().Replace("\"", "\\\"") + "\", \""
                + _razaoSocial.ToString().Trim().Replace("\"", "\\\"") + "\", \""
                + _nomeFantasia.ToString().Trim().Replace("\"", "\\\"") + "\", \""
                + _idTipoCliente + "\", \""
                + _idEnderecoRevendedor.ToString().Trim().Replace("\"", "\\\"") + "\", \""
                + _idContatoRevendedor.ToString().Trim().Replace("\"", "\\\"") + "\", \""
                + _idEnderecoCorresp.ToString().Trim().Replace("\"", "\\\"") + "\", \""
                + _cnpj.ToString().Trim().Replace("\"", "\\\"") + "\", \""
                + _inscEstadual.ToString().Trim().Replace("\"", "\\\"") + "\", \""
                + _inscMunicipal.ToString().Trim().Replace("\"", "\\\"") + "\", \""
                + _cnpjLojaConv.ToString().Trim().Replace("\"", "\\\"") + "\", \""
                + _bandeiraLojaConv.ToString().Trim().Replace("\"", "\\\"") + "\", \""
                + _servOleo.ToString().Trim().Replace("\"", "\\\"") + "\", \""
                + _tipoPosto.ToString().Trim().Replace("\"", "\\\"") + "\", \""
                + _bandeiraPosto.ToString().Trim().Replace("\"", "\\\"") + "\", \""
                + _dataContratoBandeira.ToString("yyyy-MM-dd HH:mm:ss") + "\", \""
                + _nomeContador.ToString().Trim().Replace("\"", "\\\"") + "\", \""
                + _escritorioContador.ToString().Trim().Replace("\"", "\\\"") + "\", \""
                + _idEnderecoContador.ToString().Trim().Replace("\"", "\\\"") + "\", \""
                + _idContatoContador.ToString().Trim().Replace("\"", "\\\"") + "\", \""
                + _dataContador.ToString("yyyy-MM-dd HH:mm:ss") + "\", \""
                + _informanteContador.ToString().Trim().Replace("\"", "\\\"") + "\", \""
                + _observacoes.ToString().Trim().Replace("\"", "\\\"") + "\", \""
                + _dataSolicitacao.ToString("yyyy-MM-dd HH:mm:ss") + "\", \""
                + _publicar.ToString().Trim().Replace("\"", "\\\"") + "\")";
        }
        #endregion //Data Access - Insert

        #region Data Access - Update
        protected override void DataPortal_Update()
        {
            using (OdbcConnection cn = new OdbcConnection(ConfigDatabase.MinaspetroConnection))
            {
                cn.Open();

                if (base.IsDirty)
                {
                    ExecuteUpdate(cn);
                }

                //update child object(s)
                UpdateChildren(cn);
            }//using
            MinaspetroLibrary.UsuarioPack.Usuario.UsuarioInSession.AtualizarHitorico("Update - associadotb - Id: " + _id.ToString());
        }

        private void ExecuteUpdate(OdbcConnection cn)
        {
            using (OdbcCommand cm = cn.CreateCommand())
            {
                cm.CommandType = CommandType.Text;
                cm.CommandText = GetUpdateScript();

                if (cm.ExecuteNonQuery() == 0)
                    throw new Exception("Este registro foi editado por outro usuario.");
            }//using
        }

        private string GetUpdateScript()
        {
            return "Update associadotb set "
                    + "RazaoSocial=\"" + _razaoSocial.ToString().Trim().Replace("\"", "\\\"") + "\", "
                    + "NumControle=\"" + _numControle.ToString().Trim().Replace("\"", "\\\"") + "\", "
                    + "NomeFantasia=\"" + _nomeFantasia.ToString().Trim().Replace("\"", "\\\"") + "\", "
                    + "IdTipoCliente=\"" + _idTipoCliente.ToString().Trim().Replace("\"", "\\\"") + "\", "
                    + "IdEnderecoRevendedor=\"" + _idEnderecoRevendedor.ToString().Trim().Replace("\"", "\\\"") + "\", "
                    + "IdContatoRevendedor=\"" + _idContatoRevendedor.ToString().Trim().Replace("\"", "\\\"") + "\", "
                    + "IdEnderecoCorresp=\"" + _idEnderecoCorresp.ToString().Trim().Replace("\"", "\\\"") + "\", "
                    + "Cnpj=\"" + _cnpj.ToString().Trim().Replace("\"", "\\\"") + "\", "
                    + "InscEstadual=\"" + _inscEstadual.ToString().Trim().Replace("\"", "\\\"") + "\", "
                    + "InscMunicipal=\"" + _inscMunicipal.ToString().Trim().Replace("\"", "\\\"") + "\", "
                    + "CnpjLojaConv=\"" + _cnpjLojaConv.ToString().Trim().Replace("\"", "\\\"") + "\", "
                    + "BandeiraLojaConv=\"" + _bandeiraLojaConv.ToString().Trim().Replace("\"", "\\\"") + "\", "
                    + "ServOleo=\"" + _servOleo.ToString().Trim().Replace("\"", "\\\"") + "\", "
                    + "TipoPosto=\"" + _tipoPosto.ToString().Trim().Replace("\"", "\\\"") + "\", "
                    + "BandeiraPosto=\"" + _bandeiraPosto.ToString().Trim().Replace("\"", "\\\"") + "\", "
                    + "DataContratoBandeira=\"" + _dataContratoBandeira.ToString("yyyy-MM-dd HH:mm:ss") + "\", "
                    + "NomeContador=\"" + _nomeContador.ToString().Trim().Replace("\"", "\\\"") + "\", "
                    + "EscritorioContador=\"" + _escritorioContador.ToString().Trim().Replace("\"", "\\\"") + "\", "
                    + "IdEnderecoContador=\"" + _idEnderecoContador.ToString().Trim().Replace("\"", "\\\"") + "\", "
                    + "IdContatoContador=\"" + _idContatoContador.ToString().Trim().Replace("\"", "\\\"") + "\", "
                    + "DataContador=\"" + _dataContador.ToString().Trim().Replace("\"", "\\\"") + "\", "
                    + "InformanteContador=\"" + _informanteContador.ToString().Trim().Replace("\"", "\\\"") + "\", "
                    + "Observacoes=\"" + _observacoes.ToString().Trim().Replace("\"", "\\\"") + "\", "
                    + "DataSolicitacao=\"" + _dataSolicitacao.ToString("yyyy-MM-dd HH:mm:ss") + "\", "
                    + "Publicar=\"" + _publicar.ToString().Trim().Replace("\"", "\\\"") + "\" "
                    + "WHERE Id=\"" + _id.ToString().Trim().Replace("\"", "\\\"") + "\";";
        }

        private void UpdateChildren(OdbcConnection cn)
        {
        }
        #endregion //Data Access - Update

        #region Data Access - Delete
        protected override void DataPortal_DeleteSelf()
        {
            DataPortal_Delete(new Criteria(_id));
        }

        private void DataPortal_Delete(Criteria criteria)
        {
            using (OdbcConnection cn = new OdbcConnection(ConfigDatabase.MinaspetroConnection))
            {
                cn.Open();

                ExecuteDelete(cn, criteria);

            }//using
            MinaspetroLibrary.UsuarioPack.Usuario.UsuarioInSession.AtualizarHitorico("Delete - associadotb - Id: " + _id.ToString());
        }

        private void ExecuteDelete(OdbcConnection cn, Criteria criteria)
        {
            using (OdbcCommand cm = cn.CreateCommand())
            {
                cm.CommandType = CommandType.Text;
                cm.CommandText = "DELETE from associadotb WHERE Id=\"" + criteria.Id.ToString() + "\";";

                cm.ExecuteNonQuery();
            }//using
        }
        #endregion //Data Access - Delete
        



        #region Validações
        public static Guid ValidarLoginSenha(string cnpj, string senha)
        {
            using (OdbcConnection cn = new OdbcConnection(ConfigDatabase.MinaspetroConnection))
            {
                cn.Open();

                using (OdbcCommand cm = cn.CreateCommand())
                {
                    cm.CommandType = CommandType.StoredProcedure;
                    cm.CommandText = "Select Id from associadotb where Cnpj=\"" + cnpj + "\" and NumControle=\"" + senha + "\"  and Publicar = 's';";

                    using (SafeDataReader dr = new SafeDataReader(cm.ExecuteReader()))
                    {
                        if (dr.Read())
                            return new Guid(dr["Id"].ToString());
                    }
                }
            }
            return Guid.Empty;
        }

        public static bool ExisteLogin(string cnpj)
        {
            using (OdbcConnection cn = new OdbcConnection(ConfigDatabase.MinaspetroConnection))
            {
                cn.Open();

                using (OdbcCommand cm = cn.CreateCommand())
                {
                    cm.CommandType = CommandType.Text;
                    cm.CommandText = "select Id from associadotb WHERE Cnpj = '" + cnpj + "' ";

                    using (SafeDataReader dr = new SafeDataReader(cm.ExecuteReader()))
                    {
                        return dr.Read();
                    }
                }
            }
        }

        public static bool ExisteLogin(string cnpj, Guid idExceto)
        {
            using (OdbcConnection cn = new OdbcConnection(ConfigDatabase.MinaspetroConnection))
            {
                cn.Open();

                using (OdbcCommand cm = cn.CreateCommand())
                {
                    cm.CommandType = CommandType.Text;
                    cm.CommandText = "select Id from associadotb WHERE Cnpj = '" + cnpj + "' "
                                    + " and Id != '" + idExceto.ToString() + "' and Publicar = 's'";

                    using (SafeDataReader dr = new SafeDataReader(cm.ExecuteReader()))
                    {
                        return dr.Read();
                    }
                }
            }
        }
        #endregion Validações







        #endregion //Data Access
    }
}